In-memory database system

ABSTRACT

An in-memory database system includes database table stored in system memory. The database table comprises a plurality of rows including a particular row. Data corresponding to each row is stored entirely in the system memory. The database table comprises a first version of the particular row having a first valid time, and a second version having a second valid time. Index(es) are associated with the database table. Each index is implemented as a lock-free data structure and references the plurality of rows, including referencing the first and second versions of the particular row. A first transaction acting on the first version of the particular row is executed. The first version of the particular row is visible to the first transaction based on the first valid time and the second version of the particular row being not visible to the first transaction based on the second valid time.

CROSS REFERENCE TO RELATED APPLICATION

This application is a continuation of U.S. patent application Ser. No.12/756,185, filed Apr. 8, 2010, entitled “IN-MEMORY DATABASE SYSTEM,”and which issued as U.S. Pat. No. 9,251,214 on Feb. 2, 2016, the entirecontent of which is incorporated by reference herein in its entirety.

BACKGROUND

Many database systems include storage engines that were designed basedon the assumption that data is stored on a disk and paged in and out ofmain memory when required for processing. As a result of the growth inmain memory capacity, it may be possible to store many databasesentirely in memory. Furthermore, there is a trend toward more processors(i.e., central processing unit (CPU) cores) in computer systems.

Existing in-memory storage engines are unlikely to achieve maximalperformance on current and future servers (e.g., multi-core machines).Existing in-memory storage engines use one or more frequently accesseddata structures and protect shared data by locks and latches. This maylimit the level of concurrency and the total throughput of the system(e.g., the locks and latches may become bottlenecks).

SUMMARY

Many database systems have storage engines that were designed assumingthat data would be stored on disk and frequently paged in and out ofmemory. Main memories are becoming large enough that many databases canbe stored entirely in memory. Furthermore, there is a trend toward moreprocessors (CPU cores) in modern computer systems, which may increasethe need to efficiently scale across a large number of processors.

The present disclosure describes an in-memory database system (e.g., adatabase stored entirely in a main memory of a computer system) designedfor modern multi-processor computer systems. The in-memory databasesystem is designed to improve efficiency, to allow a high degree ofconcurrency, and to provide full transaction support for modernmulti-processor computer systems. For example, the in-memory databasesystem may avoid bottlenecks associated with commonly accessed datastructures such as locks and latches. Full transaction support mayinclude atomicity, consistency, isolation, and durability (e.g., ACID)support.

The in-memory database system disclosed herein may utilize a combinationof lock-free data structures, versioning of database table rows, anon-blocking multi-version concurrency control scheme, and anon-blocking, cooperative technique for garbage collection and mayexecute transactions without blocking and thread switching.

This Summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used to limit the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram to illustrate a particular embodiment of anin-memory database system;

FIG. 2 is a diagram to illustrate another particular embodiment of anin-memory database system;

FIG. 3 is a flow diagram to illustrate a particular embodiment ofexecuting a transaction at an in-memory database system;

FIG. 4 is a flow diagram to illustrate a particular embodiment of amethod of garbage collection at an in-memory database system; and

FIG. 5 is a block diagram of a computing environment including acomputing device operable to support embodiments of computer-implementedmethods, computer program products, and system components as illustratedin FIGS. 1-4.

DETAILED DESCRIPTION

In a particular embodiment, a computer system is disclosed that includesa memory and a processor coupled to the memory. The processor isconfigured to execute instructions that cause execution of an in-memorydatabase system that includes one or more database tables. Each databasetable includes a plurality of rows, where data representing each row ofthe plurality of rows is stored in the memory. The in-memory databasesystem also includes a plurality of indexes associated with the one ormore database tables. Each index of the plurality of indexes isimplemented by a lock-free data structure. The in-memory database systemfurther includes update logic configured to update a first version of aparticular row to create a second version of the particular row. Thein-memory database system also includes a non-blocking garbage collectorconfigured to identify and deallocate data representing outdatedversions of rows. These features enable the database system to execute atransaction without blocking, thereby avoiding the overhead of threadswitching.

In another particular embodiment, a method includes receiving a requestto execute a transaction at an in-memory database system, where thetransaction is configured to update one or more rows of the in-memorydatabase system. The method includes determining a start timestamp forthe transaction and identifying a first version of the one or more rowsto be updated. The method further includes updating the first version ofthe one or more rows to create a second version of the one or more rowsat the memory. The method includes determining an end timestamp for thetransaction and committing the transaction. The second version of theone or more rows is added to one or more indexes of the in-memorydatabase system, and the first version of the one or more rows isdeallocated by a non-blocking garbage collector of the in-memorydatabase system when the first version is no longer required by anytransaction.

In another particular embodiment, a computer-readable storage mediumincludes processor executable instructions. When executed by aprocessor, the instructions cause the processor to execute anon-blocking garbage collector (GC). The GC is configured to determinean oldest active transaction at an in-memory database system by findingan active transaction having an earliest start timestamp. The GC is alsoconfigured to identify one or more terminated transactions having endtimestamps earlier than the start timestamp of the oldest activetransaction. The GC is further configured to, for each of the identifiedone or more terminated transactions, determine whether the terminatedtransaction is committed or aborted. When the terminated transaction iscommitted, the GC marks old versions of rows updated by the terminatedtransaction as garbage. When the terminated transaction is aborted, theGC marks new versions of rows created by the terminated transaction asgarbage. An execution thread that encounters a version marked as garbagemay disconnect the version from one or more indexes and deallocate theversion when it is no longer connected to any index. The GC isconfigured to track versions of rows marked as garbage that have notbeen deallocated from a memory. The GC is also configured to dispatchone or more sweeper threads of the in-memory database system todeallocate tracked versions of rows marked as garbage that have not beendeallocated by execution threads of the in-memory database system.

Main memories for servers typically grow at a rate that exceeds the rateof growth in typical OLTP database sizes. This suggests that at somepoint in the future many OLTP databases may either fit entirely in mainmemory or a significant percentage of their working set may fit in mainmemory, especially if a cluster of machines is considered. At present, a1 terabyte (TB) OLTP database may be considered large, while operatingsystems may support 2 TB of installed physical memory with no majorimpediment to extending that limit even further.

There are several consequences that may be derived from the principlesenunciated above. A first consequence is that a system that has abundantmain memory may have little use for a paging system. The reason forpaging (or for a buffer pool) is to offer the illusion of infinite orvery large memory. If the memory is large enough, use of buffer poolpages may not be necessary.

A second consequence is that, without a policy that uses buffer poolpages, there may be no reason to store undo records in a database log.Moreover, log records can be purely logical and can be grouped andwritten together at transaction commit time. In other words, each commitmay incur a single input/output (I/O) operation that contains the redorecords associated with that transaction alone. A global commit ordermay be sufficient to recover from the transaction log streams. It may bepossible to harden these transaction log streams to different devices.Recovery may involve a merge sort of the streams from each log device.Such logical logging may simplify many areas of the system (e.g.,mirroring, replication, and backup).

A third consequence is that, without a buffer pool, there may not be areason to keep rows clustered in memory in the same page format used ondisk. Rows stored on pages may cause a number of difficulties. Forexample, they may involve latching of full pages for access, split/mergepage logic, page re-arrangement code to accommodate insertion anddeletion of rows in the middle of the page, and a B-Tree (or heap)layout for search traversal. For in-memory lookup, B-Trees may not bethe most efficient data structure available, so there may be aperformance penalty associated with this layout. Moreover, pagere-arrangement, splits and merges may lead to rows being moved aroundsuch that rows can no longer be identified and de-referenced by virtualaddress. As such, another level of indirection (and additional cost) maybe added to reach any row. To avoid this, rows may be stored in theirown memory, unrelated to any clustering unit (such as the page).

FIG. 1 depicts a particular embodiment of a computer system 100 thatincludes a memory 102 and one or more processors 104 configured toexecute instructions that cause execution of an in-memory databasesystem. In one embodiment, the computer system 100 is a server systemthat includes multiple processors 104 (e.g., multiple central processingunit (CPU) cores). The in-memory database system includes at least onedatabase table 106, where each database table includes a plurality ofrows. The in-memory database system also includes a non-blocking garbagecollector (GC) 150 and a transaction map 108 stored in the memory 102.In a particular embodiment, the memory 102 includes a volatile or anon-volatile random access memory (RAM). The transaction map 108 mayrepresent active transactions (e.g., transactions being executed byexecution threads 160) at the in-memory database system. FIG. 1illustrates a database system that may be executed entirely in the mainmemory 102 (e.g., in RAM) of the computer system 100. Because all datais stored in the memory 102, no data is stored on a separate hard diskand paged in and out of the memory 102. The in-memory database system ofFIG. 1 may provide a high degree of concurrency and full transaction(ACID) support while efficiently scaling for modern hardware withmultiple processors 104.

FIG. 1 illustrates an embodiment of an in-memory database system with adatabase table 106 with a plurality of rows 110, a first index 112, anda second index 114. In an alternative embodiment, the database table 106may include any number of indexes. In another embodiment, the in-memorydatabase system includes any number of database tables. Each index isimplemented by a lock-free data structure. For example, the lockfree-data structure may be implemented using a hash set, a skip list, atree structure, or some other lock-free data structure. A hash setrepresenting an index may include a plurality of links, where each linkpoints to a list of rows having the same hash value. A skip listrepresenting an index may link all rows into a single list and a row maybe included in additional linked lists to enable faster search. In theembodiment illustrated in FIG. 1, the first index 112 is represented bya first lock-free data structure 116 and the second index 114 isrepresented by a second lock-free data structure 118.

Data representing each row of the plurality of rows 110 is stored in thememory 102. In one embodiment, the data representing each row includes afixed-size portion of the memory 102, and the fixed-size portion of thememory 102 includes a fixed-size data structure in accordance with a rowschema. In another embodiment, the data representing each row alsoincludes a variable-size portion of the memory 102, and the fixed-sizeportion includes a link to the variable-size portion. The variable-sizeportion of the memory 102 may be located at a heap storage area of thememory 102 (see heap 212 of FIG. 2 below). In one embodiment, one dataportion can point to another data portion (e.g., when the row data islarge).

The execution threads 160 may execute transactions performing retrieval,insertions, updates, and deletions at the in-memory database system inaccordance with a row versioning and concurrency control scheme. Eachrow of the database table 106 may be associated with one or moreparticular versions, where each particular version has a valid time.When a transaction updates a particular row, a new version of theparticular row may be created. In a particular embodiment, transactionsmay be classified as active transactions or terminated transactions.Terminated transactions may include committed transactions and abortedtransactions. Transactions may be aborted due to errors, commitdependencies, or another reason. For example, a transaction “Tx2” mayread data written by another transaction “Tx1.” The transaction, “Tx2”may have a commit dependency on “Tx1.” If “Tx1” fails or aborts for anyreason, “Tx2” is also required to abort. On the other hand, if “Tx2”terminates before “Tx1,” the execution thread processing “Tx2” may moveon to a new transaction, and the execution thread processing “Tx1” maycomplete processing of “Tx2.” In this way, execution threads do not needto block but continue executing as long as there is work to be done.Non-blocking transaction execution may reduce context switches at thein-memory database system, thereby conserving resources (e.g., processorcycles).

The transaction map 108 stored in the memory 102 may be configured totrack active transactions at the in-memory database system. In oneembodiment, the transaction map 108 contains pointers to transactionobjects similar to a transaction object 126. The transaction object 126may include two timestamps defining the transaction's lifetime (e.g., astart timestamp 122 and an end timestamp 124) and a transaction logincluding a sequence of operations plus a pointer to record versionsaffected by the operation. An operation may be a delete of a version(e.g., an “old” version) or an insert of a version (e.g., a “new”version). In the embodiment illustrated in FIG. 1, the transaction logof transaction object 126 contains an insert operation of a version 128(e.g., including a link 130 to data representing version 128). Thetransaction log also contains a delete operation of a version 132 (e.g.,including a link 134 to data representing version 132). Additionaloperations may also be performed. For example, the transaction log oftransaction object 126 may include a third database operation withrespect to one of the plurality of versions 110 that includes a link 142to the affected version. Similarly, the transaction log of transactionobject 126 may include a fourth database operation with respect to oneof the plurality of versions 110 that includes a link 144 to thatversion.

The in-memory database system may operate in accordance with aconcurrency control scheme. For example, versions of rows having validtimes that overlap with the transaction lifetime of a particular activetransaction may be visible to the particular active transaction, butversions of rows having valid times that do not overlap with thetransaction lifetime of the particular active transaction may not bevisible to the particular active transaction. Thus, multiple versions ofa particular row may be operated upon by the execution threads 160 atany given time. Updating a particular row may include creating a newupdated version of the particular row. Reading from a particular row mayinclude identifying an appropriate version (e.g., based on an as-of readtime specified by a particular transaction or a latest version visibleto a particular transaction) of the particular row.

Transaction isolation (i.e., logical stability) may be implemented at anin-memory database system via versioning. In one embodiment, allversions of a row are stored on the same lock-free data structure.Higher level isolation modes (e.g., repeatable read, serializable) maybe based on plain versioning. This approach may provide the benefit ofan implementation that does not penalize most users for the cost ofhigher isolation modes.

In a particular embodiment, cursors are used to access tables of thein-memory database system. A cursor may be a software class thatabstracts database operations on the table. The cursor may implement twoclasses of operations (i.e., interfaces). A first class of operationsmay be a database search operation that includes a point lookup followedby subsequent iteration. A second class of operation may be a databasemodify operation (e.g., a database insert operation, a database updateoperation, and a database delete operation) that is position agnostic.

The garbage collector (GC) 150 may identify data representing outdatedversions of rows at the in-memory database system. In a particularembodiment, a GC thread 152 identifies outdated versions of rows bydetermining an oldest active transaction at the in-memory databasesystem by finding an active transaction having an earliest starttimestamp. Scanning the transaction map 108 may be sufficient forobtaining the oldest active transaction in the system. Instead of asingle GC thread 152, it is also possible to run multiple GC threads inparallel.

Once the oldest active transaction is determined, the GC thread 152 mayidentify one or more terminated transactions having end timestamps thatare earlier than the start timestamp of the identified oldest activetransaction. In a particular embodiment, the in-memory database systemdivides transactions into generations, and the GC thread 152 identifiesgenerations of terminated transactions that are older than theidentified oldest active transaction. For each of the identifiedterminated transactions, the GC thread 152 determines whether theterminated transaction is committed or aborted. When the terminatedtransaction is committed, the GC thread 152 marks old versions of rowstracked in the terminated transaction's log as garbage. When theterminated transaction is aborted (e.g., due to an error), the GC thread152 marks new versions of rows tracked in the terminated transaction'slog as garbage.

Garbage collection at the in-memory database system may be a cooperativeprocess. The execution threads 160 may deposit completed transactions inper-CPU communication queues that may be periodically consumed by the GCthread 152. When the execution threads 160 encounter a version of a rowthat has been marked as garbage, the execution threads 160 maydeallocate the version of the row. Besides marking versions of rows asgarbage, the GC thread 152 may also maintain a garbage table 154 totrack versions of rows that have been marked as garbage but that havenot been deallocated by the execution threads 160. Periodically, the GC150 may dispatch one or more sweeper threads 156 to deallocate versionsof rows identified by the garbage table 154. Thus, the garbage table 154may enable deallocation of garbage that is not encountered by theexecution threads 160, thereby preventing unnecessary storage ofversions no longer needed.

Referring to FIG. 2, a computer system configured to executeinstructions that cause execution of an in-memory database system isillustrated at 200. Many of the elements of FIG. 2 correspond to theelements of FIG. 1. FIG. 2 illustrates further aspects of the runtimemodel of the present disclosure.

In FIG. 2, a sample row format of a record 210 associated with aparticular row (e.g., row 128) is illustrated. The sample row format ofthe record 210 includes a fixed portion and a variable portion stored ina memory heap 212. The sample row format of the record 210 containslinks 214 and 216 and a non-interpreted image of an end user row schema(e.g., an integer “Id” field and a floating point “Price” field).

FIG. 2 also illustrates a log manager 202 that is used by the in-memorydatabase system to log changes to persistent storage such as disk. Thelog manager 202 may be responsible for allocating log buffers forcommitting transactions, submitting and managing multiple outstandingI/O operations to log devices, and implementing a group commit policy atthe in-memory database system.

The log manager 202 may assemble multiple pages belonging to multipletransactions in a single log arena (e.g., log buffer). Each log arenamay be the subject of a single asynchronous I/O to the log devicesubmitted via a ‘WriteFileGather’ application programming interface(API). The log arena size (i.e., the number of pages in the arena) maybe determined dynamically based on the computed throughput for the logdevice. The log stream may keep a history of the number of recentlysubmitted pages. The log stream may also record the number of committedtransactions that have exited the current log stream in a fixed timeinterval (e.g., three seconds). If the throughput of the systemincreases relative to the recorded history, the log stream may continueto push the arena size target in the same direction as the previouschange. In other words if the arena target size was previously growingthe log stream may continue to grow it, while if the arena target sizewas shrinking, the log stream may continue to shrink it. In oneembodiment, the amount of the adjustment to the log arena size israndom.

If, on the other hand, the throughput of the current log streamdecreases, the log stream may change the direction of the targetadjustment. For example, the log stream starts growing the target if itwas previously shrinking and starts shrinking the target if it waspreviously growing. A local target arena size that efficiently utilizesthe log device may thus be determined. Since an arena contains the logrecords from one or more transactions, this approach may also result inimplementation of a throughput-directed group commit.

A log stream may contain two lists of buffers: one list of submittedI/Os and another list of overflow I/Os. The submitted list may beprotected via locks. If a thread completing validation cannot acquire alock to the submitted I/O list, the thread may append its buffers to theoverflow list. On the other hand, threads that run under the protectionof the submitted list lock may be responsible for picking up items fromthe overflow list and adding them to the submitted list. This approachmay allow the execution threads 160 to proceed without blocking. Forexample, one of the execution threads 160 that can acquire the submittedI/O lock cooperatively can pick up and complete the work of otherexecution threads 160 that could not obtain the submitted I/O lock.Execution threads 160 unable to obtain the I/O lock may have returned totransaction processing on behalf of another user.

FIG. 3 illustrates a method 300 of executing a transaction at anin-memory database system. A computer-readable storage medium may storeinstructions that, when executed by a processor, cause the processor toperform the method 300. In an illustrative embodiment, the method 300may be performed at the system 100 of FIG. 1 or the system 200 of FIG.2.

The method 300 includes receiving a request to execute a transaction atan in-memory database system, at 302. The transaction is configured toupdate one or more rows of the in-memory database system. For example,in FIG. 1, one of the execution threads 160 may receive a request toexecute the transaction 126.

The method 300 also includes determining a start timestamp for thetransaction, at 304. For example, in FIG. 1, the start timestamp 122 maybe determined. The method 300 further includes identifying a firstversion of the one or more rows that are to be updated, at 306.

The method 300 includes updating the first version of the one or morerows to create a second version of the one or more rows, at 308. Thesecond version of the one or more rows is added to one or more indexesof the in-memory database system. For example, in FIG. 1, a secondversion of the one or more rows may be created at the memory 102 and thesecond version of the one or more rows may be added to the indexes 112,114.

The method 300 includes determining an end timestamp for thetransaction, at 310, and committing the transaction, at 312. The firstversion of the one or more rows is later deallocated by a non-blockinggarbage collector of the in-memory database system when the firstversion becomes outdated. For example, in FIG. 1, the end timestamp 124may be determined, the transaction may be committed, and the GC 150 maydeallocate the first version of the one or more rows when the firstversion becomes outdated.

It will be appreciated that the method 300 of FIG. 3 may enabletransaction execution at a database system in accordance with a rowversioning scheme and a concurrency control scheme. It will thus beappreciated that the method 300 of FIG. 3 may be utilized to executemultiple concurrent transactions at a database system stored entirely inmemory (e.g., RAM).

FIG. 4 illustrates a method 400 of garbage collection at an in-memorydatabase system. A computer-readable storage medium may storeinstructions that, when executed by a processor, cause the processor toperform the method 400. In an illustrative embodiment, the method 400may be performed at the system 100 of FIG. 1 or the system 200 of FIG.2.

The method 400 includes, at a non-blocking garbage collector of anin-memory database system, determining an oldest active transactionhaving an earliest timestamp, at 402. Determining the oldest activetransaction includes scanning a transaction map for a first earliesttimestamp associated with a first active transaction, at 404. Forexample, in FIG. 1, the GC thread 152 may scan the transaction map 108.Determining the oldest active transaction may also include scanning oneor more thread local storage (TLS) locations for a second earliest starttimestamp that is associated with a second active transaction, at 406.For example, in FIG. 1, the GC thread 152 may scan TLS locationsassociated with one or more of the execution threads 160. The oldestactive transaction may be determined as the earlier of the firsttransaction and the second transaction, at 408.

The method 400 also includes identifying one or more terminatedtransactions having end timestamps earlier than the start timestamp ofthe oldest active transaction, at 410. The method 400 further includes,for each of the identified one or more terminated transactions, markingtracked versions of rows as garbage, at 412. At 414, a determination maybe made as to whether each of the terminated transactions was committedor aborted. When the terminated transaction was committed, old versionsof rows tracked by the terminated transaction may be marked as garbage,at 416. When the terminated transaction was aborted, new versions ofrows tracked by the terminated transaction may be marked as garbage, at418.

The method 400 includes tracking versions of rows marked as garbage thathave not been deallocated from a memory, at 420. For example, in FIG. 1,the garbage table 154 may be maintained to track versions of rows markedas garbage that have not been deallocated from the memory 102. Themethod 400 also includes dispatching one or more sweeper threads todeallocate the tracked versions of rows marked as garbage that are notdeallocated by execution threads, at 422. For example, in FIG. 1, thesweeper threads 156 may be dispatched.

It will be appreciated that the method 400 of FIG. 4 may enablecooperative non-blocking garbage collection at a database system. Itwill thus be appreciated that the method 400 of FIG. 4 may help preventmemory leaks at a database system stored entirely in main memory.

FIG. 5 depicts a block diagram of a computing environment 500 includinga computing device 510 operable to support embodiments ofcomputer-implemented methods, computer program products, and systemcomponents according to the present disclosure. In an illustrativeembodiment, the computing device 510 may include the system 100 of FIG.1 or the system 200 of FIG. 2.

The computing device 510 includes at least one processor 520 and asystem memory 530. For example, the system memory 530 may include thememory 102 of FIG. 1. Depending on the configuration and type ofcomputing device, the system memory 530 may be volatile (such as randomaccess memory or “RAM”), non-volatile (such as read-only memory or“ROM,” flash memory, and similar memory devices that maintain storeddata even when power is not provided), or some combination of the two.The system memory 530 typically includes an operating system 532, one ormore application platforms 534, one or more applications 536, and otherprogram instructions. For example, the system memory 530 includes one ormore database tables 535. The one or more database tables 535 mayinclude the database table 106 of FIG. 1 and FIG. 2.

The system memory 530 may also include garbage collection instructions537, deallocation instructions 538, and timestamp scanner instructions539. For example, the garbage collection instructions 537 and thetimestamp scanner instructions 539 may be associated with execution ofthe GC thread 152 of FIG. 1 and FIG. 2 (e.g., to determine an oldestactive transaction). As another example, the deallocation instructions538 may be associated with execution of the one or more sweeper threads156 of FIG. 1 and FIG. 2. The system memory 530 may further includeupdate and read logic 533. The update and read logic 533 may beconfigured to update a first version of a particular row to create asecond version of the particular row and to read data from a particularrow by identifying an appropriate version of the particular row.

The computing device 510 may also have additional features orfunctionality. For example, the computing device 510 may also includeremovable and/or non-removable additional data storage devices such asmagnetic disks, optical disks, tape, and standard-sized or flash memorycards. Such additional storage is illustrated in FIG. 5 by removablestorage 540 and non-removable storage 550. Computer storage media mayinclude volatile and/or non-volatile storage and removable and/ornon-removable media implemented in any technology for storage ofinformation such as computer-readable instructions, data structures,program components or other data. The system memory 530, the removablestorage 540 and the non-removable storage 550 are all examples ofcomputer storage media. The computer storage media includes, but is notlimited to, RAM, ROM, electrically erasable programmable read-onlymemory (EEPROM), flash memory or other memory technology, compact disks(CD), digital versatile disks (DVD) or other optical storage, magneticcassettes, magnetic tape, magnetic disk storage or other magneticstorage devices, or any other medium that can be used to storeinformation and that can be accessed by the computing device 510. Anysuch computer storage media may be part of the computing device 510.

The computing device 510 may also have input device(s) 560, such as akeyboard, mouse, pen, voice input device, touch input device, etc.Output device(s) 570, such as a display, speakers, printer, etc. mayalso be included. The computing device 510 also contains one or morecommunication connections 580 that allow the computing device 510 tocommunicate with other computing devices 590 over a wired or a wirelessnetwork.

It will be appreciated that not all of the components or devicesillustrated in FIG. 5 or otherwise described in the previous paragraphsare necessary to support embodiments as herein described. For example,the removable storage 540 may be optional.

The illustrations of the embodiments described herein are intended toprovide a general understanding of the structure of the variousembodiments. The illustrations are not intended to serve as a completedescription of all of the elements and features of apparatus and systemsthat utilize the structures or methods described herein. Many otherembodiments may be apparent to those of skill in the art upon reviewingthe disclosure. Other embodiments may be utilized and derived from thedisclosure, such that structural and logical substitutions and changesmay be made without departing from the scope of the disclosure.Accordingly, the disclosure and the figures are to be regarded asillustrative rather than restrictive.

Those of skill would further appreciate that the various illustrativelogical blocks, configurations, modules, and process steps orinstructions described in connection with the embodiments disclosedherein may be implemented as electronic hardware or computer software.Various illustrative components, blocks, configurations, modules, orsteps have been described generally in terms of their functionality.Whether such functionality is implemented as hardware or softwaredepends upon the particular application and design constraints imposedon the overall system. Skilled artisans may implement the describedfunctionality in varying ways for each particular application, but suchimplementation decisions should not be interpreted as causing adeparture from the scope of the present disclosure.

The steps of a method described in connection with the embodimentsdisclosed herein may be embodied directly in hardware, in a softwaremodule executed by a processor, or in a combination of the two. Asoftware module may reside in computer readable media, such as randomaccess memory (RAM), flash memory, read only memory (ROM), registers, ahard disk, a removable disk, a CD-ROM, or any other form of storagemedium known in the art. An exemplary storage medium is coupled to aprocessor such that the processor can read information from, and writeinformation to, the storage medium. In the alternative, the storagemedium may be integral to the processor or the processor and the storagemedium may reside as discrete components in a computing device orcomputer system.

Although specific embodiments have been illustrated and describedherein, it should be appreciated that any subsequent arrangementdesigned to achieve the same or similar purpose may be substituted forthe specific embodiments shown. This disclosure is intended to cover anyand all subsequent adaptations or variations of various embodiments.

The Abstract of the Disclosure is provided with the understanding thatit will not be used to interpret or limit the scope or meaning of theclaims. In addition, in the foregoing Detailed Description, variousfeatures may be grouped together or described in a single embodiment forthe purpose of streamlining the disclosure. This disclosure is not to beinterpreted as reflecting an intention that the claimed embodimentsrequire more features than are expressly recited in each claim. Rather,as the following claims reflect, inventive subject matter may bedirected to less than all of the features of any of the disclosedembodiments.

The previous description of the embodiments is provided to enable aperson skilled in the art to make or use the embodiments. Variousmodifications to these embodiments will be readily apparent to thoseskilled in the art, and the generic principles defined herein may beapplied to other embodiments without departing from the scope of thedisclosure. Thus, the present disclosure is not intended to be limitedto the embodiments shown herein but is to be accorded the widest scopepossible consistent with the principles and novel features as defined bythe following claims.

What is claimed is:
 1. A computer system, comprising: one or moreprocessors; a system memory; and one or more computer-readable mediahaving stored thereon computer-executable instructions that areexecutable by the one or more processors to implement an in-memorydatabase system that includes a database stored entirely in the systemmemory, the computer-executable instructions including instructions thatare executable to configure the computer system to perform at least thefollowing: store a database table in the system memory, the databasetable comprising a plurality of rows including a particular row, datacorresponding to each row being stored entirely in the system memory,the database table comprising a first version of the particular rowhaving a first valid time and a second version of the particular rowhaving a second valid time; associate one or more indexes with thedatabase table, each index being implemented as a lock-free datastructure and referencing the plurality of rows, including referencingthe first version of the particular row and the second version of theparticular row; and execute a first transaction acting on the firstversion of the particular row, the first version of the particular rowbeing visible to the first transaction based at least on the first validtime and the second version of the particular row being not visible tothe first transaction based at least on the second valid time.
 2. Thecomputer system of claim 1, wherein the first version of the particularrow is visible to the first transaction based at least on the firstvalid time overlapping a transaction lifetime of the first transaction,and the second version of the particular row is not visible to the firsttransaction based at least on the second valid time not overlapping thetransaction lifetime of the first transaction.
 3. The computer system ofclaim 1, the computer-executable instructions including alsoinstructions that are executable to configure the computer system toexecute a second transaction acting on the second version of theparticular row, the second version of the particular row being visibleto the second transaction based at least on the second valid time andthe first version of the particular row being not visible to the secondtransaction based at least on the first valid time.
 4. The computersystem of claim 3, wherein the second version of the particular row isvisible to the second transaction based at least on the second validtime overlapping a transaction lifetime of the second transaction, andthe first version of the particular row is not visible to the secondtransaction based at least on the first valid time not overlapping thetransaction lifetime of the second transaction
 5. The computer system ofclaim 1, wherein the one or more indexes are stored in the systemmemory.
 6. The computer system of claim 1, wherein the one or moreindexes comprise one or more of a hash set, a skip list, and a treestructure.
 7. The computer system of claim 1, the computer-executableinstructions including also instructions that are executable toconfigure the computer system to store a record of a plurality oftransactions, including the first transaction, in a transaction map. 8.The computer system of claim 1, the computer-executable instructionsincluding also instructions that are executable to configure thecomputer system to execute a garbage collection process that marks rowsas garbage.
 9. The computer system of claim 1, wherein the garbagecollection process marks old versions of rows tracked in a committedtransaction's log as garbage and marks new versions of rows tracked inan aborted transaction's log a garbage.
 10. The computer system of claim1, the computer-executable instructions including also instructions thatare executable to configure the computer system to persist log changesassociated with the database table to a durable storage medium.
 11. Amethod, implemented at a computer system, that includes one or moreprocessors and a system memory, for implementing an in-memory databasesystem that includes a database stored entirely in the system memory,the method comprising: storing a database table in the system memory,the database table comprising a plurality of rows including a particularrow, data corresponding to each row being stored entirely in the systemmemory, the database table comprising a first version of the particularrow having a first valid time and a second version of the particular rowhaving a second valid time; associating one or more indexes with thedatabase table, each index being implemented as a lock-free datastructure and referencing the plurality of rows, including referencingthe first version of the particular row and the second version of theparticular row; and executing a first transaction acting on the firstversion of the particular row, the first version of the particular rowbeing visible to the first transaction based at least on the first validtime and the second version of the particular row being not visible tothe first transaction based at least on the second valid time.
 12. Themethod of claim 11, wherein the first version of the particular row isvisible to the first transaction based at least on the first valid timeoverlapping a transaction lifetime of the first transaction, and thesecond version of the particular row is not visible to the firsttransaction based at least on the second valid time not overlapping thetransaction lifetime of the first transaction.
 13. The method of claim11, further comprising executing a second transaction acting on thesecond version of the particular row, the second version of theparticular row being visible to the second transaction based at least onthe second valid time and the first version of the particular row beingnot visible to the second transaction based at least on the first validtime.
 14. The method of claim 13, wherein the second version of theparticular row is visible to the second transaction based at least onthe second valid time overlapping a transaction lifetime of the secondtransaction, and the first version of the particular row is not visibleto the second transaction based at least on the first valid time notoverlapping the transaction lifetime of the second transaction
 15. Themethod of claim 11, wherein the one or more indexes are stored in thesystem memory.
 16. The method of claim 11, wherein the one or moreindexes comprise one or more of a hash set, a skip list, and a treestructure.
 17. The method of claim 11, further comprising storing arecord of a plurality of transactions, including the first transaction,in a transaction map.
 18. The method of claim 11, further comprisingexecuting a garbage collection process that marks rows as garbage. 19.The method of claim 11, wherein the garbage collection process marks oldversions of rows tracked in a committed transaction's log as garbage andmarks new versions of rows tracked in an aborted transaction's log agarbage.
 20. A computer program product comprising one or more hardwarestorage devices having stored thereon computer-executable instructionsthat are executable by one or more processors of a computer system toimplement an in-memory database system that includes a database storedentirely in system memory of the computer system, thecomputer-executable instructions including instructions that areexecutable to configure the computer system to perform at least thefollowing: store a database table in the system memory, the databasetable comprising a plurality of rows including a particular row, datacorresponding to each row being stored entirely in the system memory,the database table comprising a first version of the particular rowhaving a first valid time and a second version of the particular rowhaving a second valid time; associate one or more indexes with thedatabase table, each index being implemented as a lock-free datastructure and referencing the plurality of rows, including referencingthe first version of the particular row and the second version of theparticular row; and execute a first transaction acting on the firstversion of the particular row, the first version of the particular rowbeing visible to the first transaction based at least on the first validtime and the second version of the particular row being not visible tothe first transaction based at least on the second valid time.